JavaScript šablonų atitikimas: sąlyginis šablonų įvertinimas su 'When'

JavaScript, nors tradiciškai žinomas dėl savo dinamiškos ir lanksčios prigimties, vis dažniau perima funkcijas, kurios skatina struktūrizuotesnius ir deklaratyvesnius programavimo stilius. Viena tokių funkcijų, populiarėjanti per bibliotekas ir pasiūlymus, yra šablonų atitikimas. Šablonų atitikimas leidžia kūrėjams dekonstruoti duomenų struktūras ir vykdyti kodą, atsižvelgiant į tų struktūrų struktūrą ir reikšmes. Šiame tinklaraščio įraše gilinamasi į galingą sąlyginio šablonų įvertinimo koncepciją, naudojant 'when' sąlygą, funkciją, dažnai sutinkamą šablonų atitikimo implementacijose.

Kas yra šablonų atitikimas?

Iš esmės šablonų atitikimas yra technika, skirta patikrinti reikšmę pagal šabloną ir, jei reikšmė atitinka šabloną, išgauti reikšmės dalis tolimesniam apdorojimui. Galvokite apie tai kaip apie išraiškingesnę ir glaustesnę alternatyvą sudėtingiems įdėtiesiems `if` sakiniams ar išplėstiniams `switch` sakiniams. Šablonų atitikimas yra paplitęs funkcinio programavimo kalbose, tokiose kaip Haskell, Scala ir F#, ir vis labiau skinasi kelią į pagrindines kalbas, tokias kaip JavaScript ir Python.

JavaScript kalboje šablonų atitikimas paprastai pasiekiamas naudojant bibliotekas, tokias kaip 'ts-pattern' (skirta TypeScript), arba pasiūlymus, pavyzdžiui, šablonų atitikimo pasiūlymą, kuris šiuo metu svarstomas ECMAScript standartui.

'When' galia: sąlyginis šablonų įvertinimas

'When' sąlyga praplečia pagrindinio šablonų atitikimo galimybes, leisdama pridėti sąlyginę logiką prie jūsų šablonų. Tai reiškia, kad šablonas atitinka tik tada, kai atitinka ir reikšmės struktūra, *ir* 'when' sąlygoje nurodyta sąlyga įvertinama kaip teigiama. Tai suteikia jūsų šablonų atitikimo logikai didelį lankstumo ir tikslumo lygį.

Apsvarstykite scenarijų, kai apdorojate vartotojų duomenis iš pasaulinės e. prekybos platformos. Galbūt norėsite taikyti skirtingas nuolaidas, atsižvelgiant į vartotojo vietą ir išlaidų įpročius. Be 'when' sąlygos, jūsų šablonų atitikimo atvejuose galiausiai atsirastų įdėtieji `if` sakiniai, dėl kurių kodas taptų mažiau skaitomas ir sunkiau palaikomas. 'When' leidžia išreikšti šias sąlygas tiesiogiai šablone.

Iliustruojantys pavyzdžiai

Iliustruokime tai praktiniais pavyzdžiais. Naudosime hipotetinę biblioteką, kuri suteikia šablonų atitikimo su 'when' funkcionalumu galimybę. Atkreipkite dėmesį, kad sintaksė gali skirtis priklausomai nuo konkrečios naudojamos bibliotekos ar pasiūlymo.

1 pavyzdys: Pagrindinis tipų tikrinimas su 'When'

Tarkime, norite tvarkyti skirtingų tipų pranešimus, gautus sistemoje:

function processMessage(message) {
  match(message)
    .with({ type: "text", content: P.string }, (msg) => {
      console.log(`Apdorojamas tekstinis pranešimas: ${msg.content}`);
    })
    .with({ type: "image", url: P.string }, (msg) => {
      console.log(`Apdorojamas vaizdo pranešimas: ${msg.url}`);
    })
    .otherwise(() => {
      console.log("Nežinomas pranešimo tipas");
    });
}

processMessage({ type: "text", content: "Hello, world!" }); // Išvestis: Apdorojamas tekstinis pranešimas: Hello, world!
processMessage({ type: "image", url: "https://example.com/image.jpg" }); // Išvestis: Apdorojamas vaizdo pranešimas: https://example.com/image.jpg
processMessage({ type: "audio", file: "audio.mp3" }); // Išvestis: Nežinomas pranešimo tipas

Šiame pagrindiniame pavyzdyje atitikimą vykdome pagal `type` savybę ir kitų savybių, tokių kaip `content` ar `url`, buvimą. `P.string` yra vietos rezervavimo ženklas duomenų tipui patikrinti.

2 pavyzdys: Sąlyginis nuolaidų apskaičiavimas pagal regioną ir išlaidas

Dabar pridėkime 'when' sąlygą, kad galėtume tvarkyti nuolaidas pagal vartotojo vietą ir išlaidas:

function calculateDiscount(user) {
  match(user)
    .with(
      {
        country: "USA",
        spending: P.number.gt(100) // P.number.gt(100) tikrina, ar išlaidos yra didesnės nei 100
      },
      () => {
        console.log("Taikoma 10% nuolaida JAV vartotojams, išleidusiems daugiau nei 100 USD");
        return 0.1;
      }
    )
    .with(
      {
        country: "Canada",
        spending: P.number.gt(50)
      },
      () => {
        console.log("Taikoma 5% nuolaida Kanados vartotojams, išleidusiems daugiau nei 50 USD");
        return 0.05;
      }
    )
    .with({ country: P.string }, (u) => {
      console.log(`Nėra specialios nuolaidos vartotojams iš ${u.country}`);
      return 0;
    })
    .otherwise(() => {
      console.log("Nuolaida netaikoma.");
      return 0;
    });
}

const user1 = { country: "USA", spending: 150 };
const user2 = { country: "Canada", spending: 75 };
const user3 = { country: "UK", spending: 200 };

console.log(`Nuolaida user1: ${calculateDiscount(user1)}`); // Išvestis: Taikoma 10% nuolaida JAV vartotojams, išleidusiems daugiau nei 100 USD; Nuolaida user1: 0.1
console.log(`Nuolaida user2: ${calculateDiscount(user2)}`); // Išvestis: Taikoma 5% nuolaida Kanados vartotojams, išleidusiems daugiau nei 50 USD; Nuolaida user2: 0.05
console.log(`Nuolaida user3: ${calculateDiscount(user3)}`); // Išvestis: Nėra specialios nuolaidos vartotojams iš UK; Nuolaida user3: 0

Šiame pavyzdyje 'when' sąlyga (numanomai atstovaujama `with` funkcijoje) leidžia mums nurodyti sąlygas `spending` savybei. Prieš taikydami nuolaidą, galime patikrinti, ar išlaidos viršija tam tikrą ribą. Tai pašalina poreikį kiekviename atvejuje naudoti įdėtuosius `if` sakinius.

3 pavyzdys: Skirtingų valiutų tvarkymas su keitimo kursais

Apsvarstykime sudėtingesnį scenarijų, kai reikia taikyti skirtingus valiutų keitimo kursus, atsižvelgiant į transakcijos valiutą. Tam reikia ir šablonų atitikimo, ir sąlyginio įvertinimo:

function processTransaction(transaction) {
  match(transaction)
    .with(
      { currency: "USD", amount: P.number.gt(0) },
      () => {
        console.log(`Apdorojama USD transakcija: ${transaction.amount}`);
        return transaction.amount;
      }
    )
    .with(
      { currency: "EUR", amount: P.number.gt(0) },
      () => {
        const amountInUSD = transaction.amount * 1.1; // Tariama, kad 1 EUR = 1.1 USD
        console.log(`Apdorojama EUR transakcija: ${transaction.amount} EUR (konvertuota į ${amountInUSD} USD)`);
        return amountInUSD;
      }
    )
    .with(
      { currency: "GBP", amount: P.number.gt(0) },
      () => {
        const amountInUSD = transaction.amount * 1.3; // Tariama, kad 1 GBP = 1.3 USD
        console.log(`Apdorojama GBP transakcija: ${transaction.amount} GBP (konvertuota į ${amountInUSD} USD)`);
        return amountInUSD;
      }
    )
    .otherwise(() => {
      console.log("Nepalaikoma valiuta arba netinkama transakcija.");
      return 0;
    });
}

const transaction1 = { currency: "USD", amount: 100 };
const transaction2 = { currency: "EUR", amount: 50 };
const transaction3 = { currency: "JPY", amount: 10000 };

console.log(`Transakcijos 1 USD vertė: ${processTransaction(transaction1)}`); // Išvestis: Apdorojama USD transakcija: 100; Transakcijos 1 USD vertė: 100
console.log(`Transakcijos 2 USD vertė: ${processTransaction(transaction2)}`); // Išvestis: Apdorojama EUR transakcija: 50 EUR (konvertuota į 55 USD); Transakcijos 2 USD vertė: 55
console.log(`Transakcijos 3 USD vertė: ${processTransaction(transaction3)}`); // Išvestis: Nepalaikoma valiuta arba netinkama transakcija.; Transakcijos 3 USD vertė: 0

Nors šiame pavyzdyje `when` funkcionalumas nėra naudojamas tiesiogiai, jis parodo, kaip šablonų atitikimas apskritai gali būti naudojamas tvarkyti skirtingus scenarijus (skirtingas valiutas) ir taikyti atitinkamą logiką (valiutų keitimo kursų konversijas). 'When' sąlygą galima būtų pridėti, norint dar labiau patikslinti sąlygas. Pavyzdžiui, galėtume konvertuoti EUR į USD tik tada, jei vartotojo vieta yra Šiaurės Amerikoje, kitu atveju konvertuoti EUR į CAD.

'When' naudojimo šablonų atitikime privalumai

• Geresnis skaitomumas: Išreikšdami sąlyginę logiką tiesiogiai šablone, išvengiate įdėtųjų `if` sakinių, todėl kodas tampa lengviau suprantamas.
• Geresnis palaikymas: Deklaratyvi šablonų atitikimo su 'when' prigimtis palengvina kodo keitimą ir plėtimą. Naujų atvejų pridėjimas ar esamų sąlygų keitimas tampa paprastesnis.
• Mažiau pasikartojančio kodo: Šablonų atitikimas dažnai pašalina poreikį rašyti pasikartojantį tipų tikrinimo ir duomenų išgavimo kodą.
• Didesnis išraiškingumas: 'When' leidžia glaustai ir elegantiškai išreikšti sudėtingas sąlygas.

Svarstymai ir geriausios praktikos

• Bibliotekų/Pasiūlymų palaikymas: Šablonų atitikimo funkcijų prieinamumas ir sintaksė priklauso nuo JavaScript aplinkos ir naudojamų bibliotekų ar pasiūlymų. Pasirinkite biblioteką ar pasiūlymą, kuris geriausiai atitinka jūsų poreikius ir programavimo stilių.
• Našumas: Nors šablonų atitikimas gali pagerinti kodo skaitomumą, svarbu atsižvelgti į jo poveikį našumui. Sudėtingi šablonai ir sąlygos gali paveikti našumą, todėl svarbu profiliuoti kodą ir optimizuoti, jei reikia.
• Kodo aiškumas: Net ir naudojant 'when', būtina išlaikyti kodo aiškumą. Venkite pernelyg sudėtingų sąlygų, dėl kurių šablonus sunku suprasti. Naudokite prasmingus kintamųjų pavadinimus ir komentarus, kad paaiškintumėte savo šablonų logiką.
• Klaidų tvarkymas: Užtikrinkite, kad jūsų šablonų atitikimo logikoje būtų tinkami klaidų tvarkymo mechanizmai, skirti sklandžiai apdoroti netikėtas įvesties reikšmes. Čia labai svarbi `otherwise` sąlyga.

Pritaikymas realiame pasaulyje

Šablonų atitikimas su 'when' gali būti taikomas įvairiuose realaus pasaulio scenarijuose, įskaitant:

• Duomenų patvirtinimas: Gaunamų duomenų, tokių kaip API užklausos ar vartotojo įvestis, struktūros ir reikšmių patvirtinimas.
• Maršrutizavimas: Maršrutizavimo logikos įgyvendinimas, remiantis URL ar kitais užklausos parametrais.
• Būsenos valdymas: Programos būsenos valdymas nuspėjamu ir palaikomu būdu.
• Kompiliatorių kūrimas: Analizatorių ir kitų kompiliatoriaus komponentų įgyvendinimas.
• Dirbtinis intelektas ir mašininis mokymasis: Požymių išgavimas ir duomenų pirminis apdorojimas.
• Žaidimų kūrimas: Skirtingų žaidimo įvykių ir žaidėjo veiksmų tvarkymas.

Pavyzdžiui, apsvarstykite tarptautinės bankininkystės programą. Naudodami šablonų atitikimą su 'when', galėtumėte tvarkyti transakcijas skirtingai, atsižvelgiant į kilmės šalį, valiutą, sumą ir transakcijos tipą (pvz., įnešimas, išėmimas, pervedimas). Jums gali tekti taikyti skirtingus reguliavimo reikalavimus transakcijoms, atliekamoms iš tam tikrų šalių arba viršijančioms tam tikras sumas.

Išvada

JavaScript šablonų atitikimas, ypač derinamas su 'when' sąlyga sąlyginiam šablonų įvertinimui, siūlo galingą ir elegantišką būdą rašyti išraiškingesnį, skaitomesnį ir lengviau palaikomą kodą. Pasinaudodami šablonų atitikimu, galite žymiai supaprastinti sudėtingą sąlyginę logiką ir pagerinti bendrą savo JavaScript programų kokybę. JavaScript kalbai toliau tobulėjant, šablonų atitikimas tikriausiai taps vis svarbesniu įrankiu kūrėjo arsenale.

Ištirkite prieinamas JavaScript šablonų atitikimo bibliotekas ir pasiūlymus bei eksperimentuokite su 'when' sąlyga, kad atskleistumėte visą jos potencialą. Pritaikykite šią galingą techniką ir pakelkite savo JavaScript programavimo įgūdžius į aukštesnį lygį.